home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Information / WebSites / Eyetech / DOWNLOAD / IOBLI016.LHA / IOBlixDevKit / AutoDocs / ioblixpar.doc < prev    next >
Text File  |  1999-04-28  |  14KB  |  394 lines
  1.  
  2. TABLE OF CONTENTS
  3.  
  4. ioblixpar.device/AllocECPInfo
  5. ioblixpar.device/CMD_CLEAR
  6. ioblixpar.device/CMD_FLUSH
  7. ioblixpar.device/CMD_READ
  8. ioblixpar.device/CMD_RESET
  9. ioblixpar.device/CMD_START
  10. ioblixpar.device/CMD_STOP
  11. ioblixpar.device/CMD_WRITE
  12. ioblixpar.device/FreeECPInfo
  13. ioblixpar.device/GetChipInfo
  14. ioblixpar.device/OpenDevice
  15. ioblixpar.device/PDCMD_QUERY
  16. ioblixpar.device/PDCMD_SETPARAMS
  17.  
  18.  
  19. ioblixpar.device/AllocECPInfo                     ioblixpar.device/AllocECPInfo
  20.  
  21.    NAME
  22.        AllocECPInfo -- get the IEEE1284 probing information
  23.  
  24.    SYNOPSIS
  25.        epi = AllocECPInfo(ioRequest)
  26.        D0                     A0
  27.  
  28.        struct ECPProbeInformation *AllocECPInfo( struct IORequest * );
  29.  
  30.    FUNCTION
  31.        Modern parallel port devices are able to send some information about
  32.        themself back to the controlling machine. These information include
  33.        manufacturer, model, command sets, current state, etc.
  34.        The information block contains all these data in parsed form as well as
  35.        the string that was originally read from the device.
  36.  
  37.    INPUTS
  38.        ioRequest        - pointer to a valid ioRequest after a successfull
  39.                           OpenDevice() call.
  40.  
  41.    RESULTS
  42.        epi  - pointer to struct ECPProbeInformation, or NULL if the call
  43.               failed. If connected device is IEEE1284 compatible then
  44.               epi->epi_IsIEEE1284Compatible will be TRUE and the other fields
  45.               contain all the data that where read from the device.
  46.  
  47.    EXAMPLE
  48.        /* try to get ECP probe information */
  49.        struct IORequest *ioreq;
  50.        struct ECPProbeInformation *epi;
  51.  
  52.        if (!OpenDevice(IOBLIXPAR_NAME, 0, ioreq, 0) {
  53.          if (epi = AllocECPInfo(ioreq)) {
  54.            if (epi->epi_IsIEEE1284Compatible) {
  55.              printf("device %s was manufactured by %s\n",
  56.                     epi->epi_Description, epi->epi_Manufacturer);
  57.            } else {
  58.              printf("no IEEE1284 compatible device found\n");
  59.            }
  60.            FreeECPInfo(epi);
  61.          } else {
  62.            printf("AllocECPInfo() failed\n");
  63.          }
  64.          CloseDevice(ioreq);
  65.        }
  66.  
  67.    SEE ALSO
  68.        ioblixpar.device/CMD_READ, FreeECPInfo
  69.  
  70.  
  71. ioblixpar.device/CMD_CLEAR                           ioblixpar.device/CMD_CLEAR
  72.  
  73.    NAME
  74.         Clear -- clear the parallel port buffer
  75.  
  76.    FUNCTION
  77.         This command just RTS's (no buffer to clear)
  78.  
  79.    IO REQUEST
  80.         io_Message      mn_ReplyPort initialized
  81.         io_Device       set by OpenDevice
  82.         io_Unit         set by OpenDevice
  83.         io_Command      CMD_CLEAR (05)
  84.  
  85.  
  86. ioblixpar.device/CMD_FLUSH                           ioblixpar.device/CMD_FLUSH
  87.  
  88.    NAME
  89.         Flush -- clear all queued I/O requests for the parallel port
  90.  
  91.    FUNCTION
  92.         This command purges the read and write request queues for the
  93.         parallel device. The currently active request is not purged.
  94.  
  95.    IO REQUEST
  96.         io_Message      mn_ReplyPort initialized
  97.         io_Device       set by OpenDevice
  98.         io_Unit         set by OpenDevice
  99.         io_Command      CMD_FLUSH (08)
  100.  
  101.  
  102. ioblixpar.device/CMD_READ                             ioblixpar.device/CMD_READ
  103.  
  104.    NAME
  105.         Read -- read input from parallel port
  106.  
  107.    FUNCTION
  108.         This command causes a stream of characters to be read from the
  109.         parallel I/O register. The number of characters is specified in
  110.         io_Length. The EOF and EOL modes are supported, but be warned that
  111.         using these modes can result in a buffer overflow if the proper
  112.         EOL or EOF character is not received in time. These modes should
  113.         be used only when the sender and receiver have been designed to
  114.         cooperate. A safety guard can be implemented to EOF by setting
  115.         io_Length to a maximum allowed value. That cannot be done with EOL
  116.         since the EOL mode is identified by io_Length=-1.
  117.  
  118.         The ioblixpar.device has no internal buffer; if no read request has
  119.         been made, pending input (i.e. handshake request) is not
  120.         acknowledged.
  121.  
  122.         ioblixpar.device does IEEE1284 reads. This means if the connected
  123.         device is not IEEE1284 compatible io_Error will be set to
  124.         ParErr_NotIEEE1284. On success the unparsed data will be returned in
  125.         io_Data with io_Length set to the amount of data read.
  126.  
  127.    IO REQUEST
  128.         io_Message      mn_ReplyPort initialized
  129.         io_Device       set by OpenDevice
  130.         io_Unit         set by OpenDevice
  131.         io_Command      CMD_READ (02)
  132.         io_Flags        If IOF_QUICK is set, driver will attempt Quick IO
  133.         io_Length       number of characters to receive.
  134.         io_Data         pointer where to put the data.
  135.  
  136.    RESULTS
  137.         io_Error -- if the Read succeded, then io_Error will be null.
  138.             If the Read failed, then io_Error will contain an error code.
  139.  
  140.    SEE ALSO
  141.         ioblixpar.device/PDCMD_SETPARAMS, ioblixpar.device/AllocECPInfo
  142.  
  143.  
  144. ioblixpar.device/CMD_RESET                           ioblixpar.device/CMD_RESET
  145.  
  146.    NAME
  147.         Reset -- reinitializes the parallel device
  148.  
  149.    FUNCTION
  150.         This command resets the parallel device to its freshly initialized
  151.         condition. It aborts all I/O requests both queued and current and
  152.         sets the devices's flags and parameters to their boot-up time 
  153.         default values. At boot-up time the PTermArray is random, and it
  154.         will be so also here.
  155.  
  156.    IO REQUEST
  157.         io_Message      mn_ReplyPort initialized
  158.         io_Device       set by OpenDevice
  159.         io_Unit         set by OpenDevice
  160.         io_Command      CMD_RESET (01)
  161.  
  162.    RESULTS
  163.         Error -- if the Reset succeded, then io_Error will be null.
  164.                  if the Reset failed, then the io_Error will be non-zero.
  165.  
  166.  
  167. ioblixpar.device/CMD_START                           ioblixpar.device/CMD_START
  168.  
  169.    NAME
  170.         Start -- restart paused I/O over the parallel port
  171.  
  172.    FUNCTION
  173.         This command restarts the current I/O activity on the parallel
  174.         port by reactivating the handshaking sequence.
  175.  
  176.    IO REQUEST
  177.         io_Message      mn_ReplyPort initialized
  178.         io_Device       set by OpenDevice
  179.         io_Unit         set by OpenDevice
  180.         io_Command      CMD_START (07)
  181.  
  182.    SEE ALSO
  183.         ioblixpar.device/CMD_STOP
  184.  
  185.  
  186. ioblixpar.device/CMD_STOP                             ioblixpar.device/CMD_STOP
  187.  
  188.    NAME
  189.         Stop -- pause current activity on the parallel device
  190.  
  191.    FUNCTION
  192.         This command halts the current I/O activity on the parallel
  193.         device by discontinuing the handshaking sequence. The stop and
  194.         start commands may not be nested.
  195.  
  196.    IO REQUEST
  197.         io_Message      mn_ReplyPort initialized
  198.         io_Device       set by OpenDevice
  199.         io_Unit         set by OpenDevice
  200.         io_Command      CMD_STOP (06)
  201.  
  202.    SEE ALSO
  203.         ioblixpar.device/CMD_START
  204.  
  205.  
  206. ioblixpar.device/CMD_WRITE                           ioblixpar.device/CMD_WRITE
  207.  
  208.    NAME
  209.         Write -- send output to parallel port
  210.  
  211.    FUNCTION
  212.         This command causes a stream of characters to be written to the
  213.         parallel output register. The number of characters is specified in
  214.         io_Length, unless -1 is used, in which case output is sent until
  215.         a zero byte occurs in the data. This is independent of, and may be
  216.         used simultaneously with setting the EOFMODE in io_ParFlags and using
  217.         the PTermArray to terminate the read or write.
  218.  
  219.    IO REQUEST
  220.         io_Message      mn_ReplyPort initialized
  221.         io_Device       set by OpenDevice
  222.         io_Unit         set by OpenDevice
  223.         io_Command      CMD_WRITE (03)
  224.         io_Flags        If IOF_QUICK is set, driver will attempt Quick IO
  225.         io_Length       number of characters to transmit, or if set
  226.                         to -1 send until zero byte encountered
  227.         io_Data         pointer to block of data to transmit
  228.  
  229.    RESULTS
  230.         io_Error -- If the Write succeded, then io_Error will be null.
  231.              If the Write failed, then io_Error will contain an error code.
  232.  
  233.    SEE ALSO
  234.         ioblixpar.device/PDCMD_SETPARAMS
  235.  
  236.  
  237. ioblixpar.device/FreeECPInfo                       ioblixpar.device/FreeECPInfo
  238.  
  239.    NAME
  240.        FreeECPInfo -- free the IEEE1284 probing information
  241.  
  242.    SYNOPSIS
  243.        FreeECPInfo(epi)
  244.                   A0
  245.  
  246.        void FreeECPInfo( struct ECPProbeInformation * );
  247.  
  248.    FUNCTION
  249.        Free the gathered ECP probing information again. Each AllocECPInfo()
  250.        call should be balanced by exactly one FreeECPInfo() call to avoid
  251.        memory leaks.
  252.  
  253.    INPUTS
  254.        epi - pointer to a previously allocated ECP information block. Passing
  255.              NULL is a no-op.
  256.  
  257.    SEE ALSO
  258.        AllocECPInfo
  259.  
  260.  
  261. ioblixpar.device/GetChipInfo                       ioblixpar.device/GetChipInfo
  262.  
  263.    NAME
  264.        GetChipInfo -- get the chip's information block
  265.  
  266.    SYNOPSIS
  267.        chipInfo = GetChipInfo(ioRequest)
  268.        D0                     A0
  269.  
  270.        struct IOBlixChipNode *GetChipInfo(struct IORequest *);
  271.  
  272.    FUNCTION
  273.        Get the chip's information block, as it is returned by
  274.        ioblix.resource/ObtainChip() and ioblix.resource/FindChip(). All fields
  275.        are considered READ-ONLY, you must not change anything.
  276.  
  277.    INPUTS
  278.        ioRequest        - pointer to a valid ioRequest after a successfull
  279.                           OpenDevice() call.
  280.  
  281.    RESULTS
  282.        chipInfo  - the chip's information block
  283.  
  284.    SEE ALSO
  285.        ioblix.resource/ObtainChip, ioblix.resource/FindChip
  286.  
  287.  
  288. ioblixpar.device/OpenDevice                         ioblixpar.device/OpenDevice
  289.  
  290.    NAME
  291.         Open -- a request to open the parallel port
  292.  
  293.    SYNOPSIS
  294.         error = OpenDevice("ioblixpar.device", unit, ioExtPar, flags)
  295.         D0                  A0                 D0    A1        D1
  296.  
  297.    FUNCTION
  298.         This function allows the requestor software access to the parallel
  299.         device.  Unless the shared-access bit (bit 5 of io_ParFlags) is
  300.         set, exclusive use is granted and no other access is allowed
  301.         until the owner closes the device.
  302.  
  303.         The PTermArray of the ioExtPar is initialized only if the EOFMODE
  304.         bit (bit 1 of io_ParFlags) is set. The PTermArray can be further
  305.         modified using the PDCMD_SETPARAMS command.
  306.  
  307.    INPUTS
  308.         "ioblixpar.device" - a pointer to literal string "ioblixpar.device"
  309.         unit - Must be zero for future compatibility
  310.         ioExtPar - pointer to an IO Request block of structure IOExtPar to
  311.                    be initialized by the Open() function. The io_ParFlags
  312.                    field must be set as desired.
  313.         flags - Must be zero for future compatibility
  314.  
  315.    RESULTS
  316.         d0 -- same as io_Error
  317.         io_Error -- if the Open succeded, then io_Error will be null.
  318.                     If the Open failed, then io_Error will be non-zero.
  319.  
  320.    SEE ALSO
  321.         exec/CloseDevice
  322.  
  323.  
  324. ioblixpar.device/PDCMD_QUERY                       ioblixpar.device/PDCMD_QUERY
  325.  
  326.    NAME
  327.         Query -- query parallel port/line status
  328.  
  329.    FUNCTION
  330.         This command return the status of the parallel port lines and
  331.         registers. 
  332.  
  333.    IO REQUEST
  334.         io_Message      must have mn_ReplyPort initialized
  335.         io_Device       set by OpenDevice
  336.         io_Unit         set by OpenDevice
  337.         io_Command      PDCMD_QUERY (09)
  338.  
  339.    RESULTS
  340.         io_Status        BIT  ACTIVE  FUNCTION
  341.  
  342.                          0     high   printer busy toggle (offline)
  343.                          1     high   paper out
  344.                          2     high   printer selected
  345.                          3      -     read=0,write=1
  346.                        4-7            reserved
  347.  
  348.  
  349. ioblixpar.device/PDCMD_SETPARAMS               ioblixpar.device/PDCMD_SETPARAMS
  350.  
  351.    NAME
  352.         SetParams -- change parameters for the parallel device
  353.  
  354.    FUNCTION
  355.         This command allows the caller to change the EOFMODE parameter for
  356.         the parallel port device. It will disallow changes if any reads or
  357.         writes are active or queued.  
  358.  
  359.         The PARB_EOFMODE bit of io_ParFlags controlls whether the
  360.         io_PTermArray is to be used as an additional termination criteria
  361.         for reads and writes.  It may be set directly without a call to
  362.         SetParams, setting it here performs the additional service of
  363.         copying the PTermArray into the device default array which is used
  364.         as the initial array for subsequent device opens. The Shared bit
  365.         can be changed here, and overrides the current device access mode
  366.         set at OpenDevice time.
  367.  
  368.    IO REQUEST
  369.         io_Message      mn_ReplyPort initialized
  370.         io_Device       preset by OpenDevice
  371.         io_Unit         preset by OpenDevice
  372.         io_Command      PDCMD_SETPARAMS (0A)
  373.                         NOTE that the following fields of your IORequest
  374.                         are filled by Open to reflect the parallel device's
  375.                         current configuration.
  376.         io_PExtFlags    must be set to zero, unless used
  377.         io_ParFlags     see definition in parallel.i or parallel.h
  378.                         NOTE that 0x00 yields exclusive access, PTermArray
  379.                         inactive.
  380.         io_PTermArray   ASCII descending-ordered 8-byte array of
  381.                         termination characters. If less than 8 chars
  382.                         used, fill out array w/lowest valid value.
  383.                         Terminators are used only if EOFMODE bit of
  384.                         io_Parflags is set. (e.g. x512F040303030303 )
  385.                         This field is filled on OpenDevice only if the
  386.                         EOFMODE bit is set.
  387.  
  388.    RESULTS
  389.         io_Error -- if the SetParams succeded, then io_Error will be null.
  390.                     if the SetParams failed, then io_Error will be non-zero.
  391.  
  392.  
  393.  
  394.